package com.ruoyi.jihuo.config;

import com.ruoyi.common.utils.StringUtils;
import com.taobao.top.schema.enums.RuleTypeEnum;
import com.taobao.top.schema.field.*;
import com.taobao.top.schema.option.Option;
import com.taobao.top.schema.rule.RegexRule;
import com.taobao.top.schema.rule.Rule;
import com.taobao.top.schema.value.ComplexValue;
import com.taobao.top.schema.value.Value;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @Author：LXY
 * @DATE：2025-09-01 09:55
 * @Description：
 */
public class FieldDisposeConfig {
    /**
     * 复合型处理
     *
     * @param v
     * @param categoryData
     */
    public static void disposeMultiComplex(Field v, Map<String, String> categoryData) {
        String[] multiValues = categoryData.get(v.getName()).split(" ");
        for (String s : multiValues) {
            ComplexValue complexValue = new ComplexValue();
            // 这里原rule 必须有顺序，否则无法解析
            ((MultiComplexField) v).getFieldList().forEach(f -> {
                switch (f.getType()) {
                    case SINGLECHECK:
                        ((SingleCheckField) f).getOptions()
                                .stream()
                                .filter(o -> s.contains(o.getDisplayName()))
                                .findFirst()
                                .map(Option::getValue)
                                .map(Value::new)
                                .ifPresent(optionValue -> complexValue.setSingleCheckFieldValue(f.getId(), optionValue));
                        break;
                    case INPUT:
                        // todo 暂时硬编码，目前只看到 %
                        f.getRules().forEach(r -> {
                            if (r instanceof RegexRule) {
                                String regex = r.getValue().substring(1, r.getValue().length() - 1);
                                complexValue.setInputFieldValue(f.getId(), extractValue(s, regex));
                            }
                        });
                        break;
                }
            });
            ((MultiComplexField) v).addComplexValue(complexValue);
        }
    }

    /**
     * 单选类型处理
     * 当传入单选值不为空，且option中没有时，输入-1
     *
     * @param v            v v.getOptions包含了所有的选项
     * @param originalData 是商品数据包中的选项(！如果数据包中的数据不符合选项中的选项时，默认赋值为选项中最后一个选项)
     */
    public static void disposeSingleCheck(SingleCheckField v, String originalData) {
        Value value = null;
        Map<String, String> optionsMap = new HashMap<>();
        for (Option option : v.getOptions()) {
            optionsMap.put(option.getDisplayName(), option.getValue());
        }
        if (optionsMap.containsKey(originalData)) {
            value = new Value(optionsMap.get(originalData));
        } else if (StringUtils.isNotBlank(originalData)) {
            value = new Value("-1");
        } else {
            value = new Value(v.getOptions().get(0).getValue());
        }
        v.setValue(value);
    }

    /**
     * 多选类型处理
     *
     * @param v            v.getOptions包含了所有的选项
     * @param originalData 是商品数据包中的选项(！如果数据包中的数据没有一条符合选项中的时，默认赋值为选项中最后一个选项)
     */
    public static void disposeMultiCheck(MultiCheckField v, String originalData) {
        List<Value> values = new ArrayList<>();
        Map<String, String> optionsMap = new HashMap<>();
        for (Option option : v.getOptions()) {
            optionsMap.put(option.getDisplayName(), option.getValue());
        }
        if (StringUtils.isNotBlank(originalData)) {
            String[] split = originalData.split(" ");
            for (String s : split) {
                if (optionsMap.containsKey(s)) {
                    values.add(new Value(optionsMap.get(s)));
                }
            }
        }
        if (values.isEmpty()) {
            values.add(new Value(v.getOptions().get(0).getValue()));
        }
        v.setValues(values);
    }

    /**
     * 判断字段是否为必填字段(包含以下两个规则名称且value为true时为必填项)
     *
     * @param v
     * @return
     */
    public static boolean isRequiredFields(Field v) {
        AtomicBoolean isRequired = new AtomicBoolean(false);
        v.getRules().forEach(r -> {
            if (RuleTypeEnum.REQUIRED_RULE.toString().equals(r.getName())) {
                if (r.getValue().equals("true")) {
                    isRequired.set(true);
                }
            }
            if (RuleTypeEnum.TIP_RULE.toString().equals(r.getName())) {
                if (r.getValue().equals("该属性为重要属性")) {
                    isRequired.set(true);
                }
            }
        });
        return isRequired.get();
    }

    /**
     * 判断字段是否为必填字段(包含以下两个规则名称且value为true时为必填项)
     *
     * @param v
     * @return
     */
    public static boolean isDelayFields(Field v) {
        AtomicBoolean idDelay = new AtomicBoolean(false);
        v.getRules().forEach(r -> {
            if (RuleTypeEnum.DISABLE_RULE.toString().equals(r.getName())) {
                if (r.getValue().equals("true")) {
                    idDelay.set(true);
                }
            }
        });
        return idDelay.get();
    }

    /**
     * 文本输入类型处理
     *
     * @param v
     * @param originalData 是商品数据包中的数据（数据包数据为空时，采用自定义赋值）
     */
    public static void disposeInput(InputField v, String originalData) {
        if (StringUtils.isBlank(originalData)) {
            v.setValue(ruleGeneration(v.getRules()));
        } else {
            v.setValue(originalData);
        }
    }
    public static String ruleGeneration(List<Rule> rules){
        String resultValue="1";//数值
        String resultUnit="";//单位
        for (Rule rule : rules) {
            //当给定的默认值 小于最小值时，默认值等于最小值
            if("minValueRule".equals(rule.getName())){
                double value = Double.parseDouble(rule.getValue());
                double currentResult = Double.parseDouble(resultValue);
                if(currentResult < value) {
                    resultValue = String.valueOf(value);
                }
            }
            //当给定的规则中存在单位时，随机匹配长度、重量单位
            if("tipRule".equals(rule.getName())){
                String value = rule.getValue();
                resultUnit=getUnit(value);
            }
        }
        return resultValue+resultUnit;
    }
    public static String getUnit(String str){
        String unit = "";
        String[] lengthUnit ={"cm", "mm", "m"};
        String[] weightUnit ={"mg", "g", "kg"};
        for (String lUnit : lengthUnit) {
            if (str.contains(lUnit)) {
                unit = lUnit;
                break;
            }
        }
        if (StringUtils.isBlank(unit)){
            for (String wUnit : weightUnit) {
                if (str.contains(wUnit)) {
                    unit = wUnit;
                    break;
                }
            }
        }
        return unit;
    }
    public static String extractValue(String input, String regex) {
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(input);

        while (matcher.find()) {
            String extractedValue = matcher.group();
            if (input.contains(extractedValue + "%")) {
                return extractedValue;
            }
        }
        return null; // 如果没有匹配到，返回null
    }

}
